Jump to content
marciniak

Ajuda! - Preenchimento de string através de função

Recommended Posts

Salve!
Estou tentando escrever em uma string (ponteiro alocado dinamicamente) através de uma função alimentada por um ponteiro
Codigo de exemplo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void teste (char *str)
{
    str = (char*)malloc(sizeof(char)*(strlen("teste")));
    strcpy(str, "teste");

    printf("%s", str);
}

int main()
{
    char *str1 = NULL;

    teste(str1);

    printf("|%s", str1);

    return 0;
}

 

A intenção é que a saída seja algo do tipo:

teste|teste

porém o resultado é:

teste|(null)

 

Acredito que por estar enviando como referência o str1 ele deveria ser alterado pela função, e portanto permanecer como o mesmo valor de str (que aponta para ele), porém isso não acontece.
Como deveria proceder para conseguir o resultado desejado?

Agradeço!

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

  • Similar Content

    • By TK_T
      olá sou iniciante consegui fazer um o código de um exercício só que quando eu peço o valor 12ab ele lê como numérica alguém pode me ajudar? 
      Exercício: Leia uma string e diga se a mesma é numérica (na base decimal) ou não.
      Ex.: "123" -> numérica
      "abc" -> não numérica
      "12ab" -> não numérica
      "12.34" -> numérica 
      #include <stdio.h> int main() { char Numero; printf("Digite Algo: "); scanf("%c", &Numero); if(Numero == '1' || Numero == '2' || Numero == '3' || Numero == '4' || Numero == '5' || Numero == '6' || Numero == '7' || Numero == '8' || Numero== '9' || Numero == '0') printf("\tNumérica...\n"); else printf("\tNão Numérica\n"); return 0; }  
    • By mateus.andriollo
      Boa tarde,
      Tenho alguns campos numéricos q ao fazer uma select gostaria q retornasse uma legenda
       
      exemplo:
      Status: 0=Inativo / 1=Ativo Condição: 1=Funcionando / 2=Em manutenção / 3=Manutenção Interna   
      Seria algo assim, tenho varias tabelas com estes campos... mas tenho q ficar usando replace.
      Existe uma forma de criar uma função para isso? Nem q na função eu tenha que setar nome do campo, ficando assim:
      Legenda('Status',cadastro.status) 
    • By clayton.lima2020
      Boa Tarde!
       
      Pessoal estou com um problema para resolver:
       
      Tenho um uma string que é um Nome:  SYLVIA
       
      Eu preciso fazer uma uma busca nessa string achar a letra Y e depois verificar se após a letra Y a próxima letra é Vogal ou Consoante.
       
      No caso do nome SYLVIA a próxima letra é L então retorna Consoante.
       
      Alguém sabe montar esse algoritmo ai?
    • By unset
      Olá, estou com uma pequena dúvida 
       
      Como transformar a data que recebemos com a função date("Y-m-d H:i") em uma string 2021-04-22T00:00 exatamente nesse formato ?
    • By Mateus GP
      Boa noite.
       
      Estou tendo problemas para compilar um código, não tenho ideia do que está acontecendo.
       
       
      main.cpp
      #include <iostream> #include "vector2.hpp" int main(int, char **) { Vector2f test; //test = (const float)0.0f; test.dot(test); return 0; } vector2.hpp
      #ifndef vector2_header #define vector2_header #include <cmath> template <typename number_t> class Vector2; template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs); template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs); template <typename number_t> Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs); template <typename number_t> class Vector2 { public: number_t x; number_t y; Vector2() : x(0.), y(0.) {} Vector2(const number_t x_, const number_t y_) : x(x_), y(y_) {} Vector2(const Vector2 &v2d) : x(v2d.x), y(v2d.y) {} friend Vector2 operator+<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator+<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator+<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator-<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator-<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator-<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator*<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator*<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator*<number_t>(const number_t lhs, const Vector2 &rhs); friend Vector2 operator/<number_t>(const Vector2 &lhs, const Vector2 &rhs); friend Vector2 operator/<number_t>(const Vector2 &lhs, const number_t rhs); friend Vector2 operator/<number_t>(const number_t lhs, const Vector2 &rhs); Vector2 &operator=(const Vector2 &rhs); Vector2 &operator=(const number_t &rhs); Vector2 &operator+=(const Vector2 &rhs); Vector2 &operator+=(const number_t rhs); Vector2 &operator-=(const Vector2 &rhs); Vector2 &operator-=(const number_t rhs); Vector2 &operator*=(const Vector2 &rhs); Vector2 &operator*=(const number_t rhs); Vector2 &operator/=(const Vector2 &rhs); Vector2 &operator/=(const number_t rhs); number_t lenghtSq() const; number_t lenght() const; number_t dot(const Vector2 &rhs) const; number_t cross(const Vector2 &rhs) const; Vector2 &rotate(const number_t rad); Vector2 rotated(const number_t rad) const; Vector2 &normalize(); Vector2 normalized() const; number_t distanceSq(const Vector2 &rhs) const; number_t distance(const Vector2 &rhs) const; number_t angle(const Vector2 &rhs) const; Vector2 absv() const; }; typedef Vector2<float> Vector2f; #endif // !vector2_header vector2.cpp
      #include "vector2.hpp" template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x + rhs.x, lhs.y + rhs.y); } template <typename number_t> Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x + rhs, lhs.y + rhs); } template <typename number_t> Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs + rhs.x, lhs + rhs.y); } template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x - rhs.x, lhs.y - rhs.y); } template <typename number_t> Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x - rhs, lhs.y - rhs); } template <typename number_t> Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs - rhs.x, lhs - rhs.y); } template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x * rhs.x, lhs.y * rhs.y); } template <typename number_t> Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x * rhs, lhs.y * rhs); } template <typename number_t> Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs * rhs.x, lhs * rhs.y); } template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs.x / rhs.x, lhs.y / rhs.y); } template <typename number_t> Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs) { return Vector2<number_t>(lhs.x / rhs, lhs.y / rhs); } template <typename number_t> Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs) { return Vector2<number_t>(lhs / rhs.x, lhs / rhs.y); } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator=(const Vector2<number_t> &rhs) { if(this != &rhs) { x = rhs.x; y = rhs.y; } return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator=(const number_t &rhs) { x = rhs; y = rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator+=(const Vector2<number_t> &rhs) { x += rhs.x; y += rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator+=(const number_t rhs) { x += rhs; y += rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator-=(const Vector2<number_t> &rhs) { x -= rhs.x; y -= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator-=(const number_t rhs) { x -= rhs; y -= rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator*=(const Vector2<number_t> &rhs) { x *= rhs.x; y *= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator*=(const number_t rhs) { x *= rhs; y *= rhs; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator/=(const Vector2<number_t> &rhs) { x /= rhs.x; y /= rhs.y; return *this; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::operator/=(const number_t rhs) { x /= rhs; y /= rhs; return *this; } template <typename number_t> number_t Vector2<number_t>::lenghtSq() const { return x * x + y * y; } template <typename number_t> number_t Vector2<number_t>::lenght() const { return sqrt(x * x + y * y); } template <typename number_t> number_t Vector2<number_t>::dot(const Vector2<number_t> &rhs) const { return x * rhs.x + y * rhs.y; } template <typename number_t> number_t Vector2<number_t>::cross(const Vector2<number_t> &rhs) const { return x * rhs.x - y * rhs.y; } template <typename number_t> Vector2<number_t> &Vector2<number_t>::rotate(const number_t rad) { const number_t tx(x), dc(cos(rad)), ds(sin(rad)); x = x * dc - y * ds; y = tx * ds + y * dc; return *this; } template <typename number_t> Vector2<number_t> Vector2<number_t>::rotated(const number_t rad) const { Vector2<number_t> nw(*this); return nw.rotate(rad); } template <typename number_t> Vector2<number_t> &Vector2<number_t>::normalize() { const number_t len(1. / lenght()); x *= len; y *= len; return *this; } template <typename number_t> Vector2<number_t> Vector2<number_t>::normalized() const { Vector2<number_t> nw(*this); return nw.normalize(); } template <typename number_t> number_t Vector2<number_t>::distanceSq(const Vector2<number_t> &rhs) const { const number_t dx(x - rhs.x); const number_t dy(y - rhs.y); return dx * dx + dy * dy; } template <typename number_t> number_t Vector2<number_t>::distance(const Vector2<number_t> &rhs) const { const number_t dx(x - rhs.x); const number_t dy(y - rhs.y); return sqrt(dx * dx + dy * dy); } template <typename number_t> number_t Vector2<number_t>::angle(const Vector2<number_t> &rhs) const { Vector2<number_t> nv(normalized()); number_t ang(nv.dot(rhs.normalized())); if (ang > 1.0) ang = 1.0; if (ang < -1.0) ang = -1.0; return -acos(ang); } template <typename number_t> Vector2<number_t> Vector2<number_t>::absv() const { return Vector2<number_t>(abs(x), abs(y)); } O problema é que aparentemente funciona se copiar o código de vector2.cpp para main.cpp.
       
      Alguém tem alguma sugestão? Se houver outra fora o problema, também é bem-vinda.
       
      Obs: já tentei compilar pelo terminal também.
       
      CMakeLists.txt
       
×

Important Information

Ao usar o fórum, você concorda com nossos Terms of Use.